home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Graphics⁄Sound / RTrace-1.0-src / params.c < prev    next >
Text File  |  1992-09-01  |  19KB  |  645 lines
  1. /*
  2.  * Copyright (c) 1988, 1992 Antonio Costa, INESC-Norte.
  3.  * All rights reserved.
  4.  *
  5.  * This code received contributions from the following people:
  6.  *
  7.  *  Roman Kuchkuda      - basic ray tracer
  8.  *  Mark VandeWettering - MTV ray tracer
  9.  *  Augusto Sousa       - overall, shading model
  10.  *
  11.  * Redistribution and use in source and binary forms are permitted
  12.  * provided that the above copyright notice and this paragraph are
  13.  * duplicated in all such forms and that any documentation,
  14.  * advertising materials, and other materials related to such
  15.  * distribution and use acknowledge that the software was developed
  16.  * by Antonio Costa, at INESC-Norte. The name of the author and
  17.  * INESC-Norte may not be used to endorse or promote products derived
  18.  * from this software without specific prior written permission.
  19.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  20.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  21.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  22.  */
  23. #include "defs.h"
  24. #include "extern.h"
  25.  
  26. /**********************************************************************
  27.  *    RAY TRACING - Parameters - Version 7.3.2                        *
  28.  *                                                                    *
  29.  *    MADE BY    : Antonio Costa, INESC-Norte, October 1988           *
  30.  *    ADAPTED BY : Antonio Costa, INESC-Norte, June 1989              *
  31.  *    MODIFIED BY: Antonio Costa, INESC-Norte, August 1992            *
  32.  **********************************************************************/
  33.  
  34. /***** Command line parameters *****/
  35. #define THRESHOLD_COLOR(x) (3.0 * SQR(x))
  36.  
  37. static void
  38. defaults()
  39. {
  40.   screen_size_x = 0;
  41.   screen_size_y = 0;
  42.   threshold_level = 0.01;
  43.   threshold_color = THRESHOLD_COLOR(0.05);
  44.   last_shade_level = 7;
  45.   sampling_levels = 0;
  46.   sampling_divisions = 1 SHL sampling_levels;
  47.   sampling_weight = 4 * SQR(sampling_divisions);
  48.   cluster_size = 4;
  49.   last_ambient_level = 0;
  50.   ambient_sample_rays = 16;
  51.   antialiasing_mode = 0;
  52.   background_mode = 0;
  53.   raw_mode = 0;
  54.   light_mode = 0;
  55.   shade_mode = 1;
  56.   normal_mode = 0;
  57.   normal_check_mode = 0;
  58.   texture_mode = 0;
  59.   view_mode = 0;
  60.   intersect_mode = 0;
  61.   intersect_adjust_mode = 0;
  62.   jittering_mode = 0;
  63.   distributed_cache_mode = 0;
  64.   focal_aperture = 0.0;
  65.   focal_distance = 0.0;
  66.   stereo_separation = 0.0;
  67.   output_format = 0;    /* PIC */
  68. #ifdef ECHO
  69.   verbose_mode = 3;
  70. #else
  71.   verbose_mode = 2;
  72. #endif
  73. }
  74. static void
  75. usage()
  76. {
  77. #ifndef lint
  78.   extern char     copyright[];
  79.  
  80.   WRITE(ERROR, "%s", &(copyright[5]));
  81.   WRITE(ERROR, "Version %s created on %s %s.\n",
  82.         PROGRAM_VERSION, __DATE__, __TIME__);
  83. #endif
  84.   WRITE(ERROR, "Usage: {PROGRAM}\n");
  85.   WRITE(ERROR, "  [w]Screen Width       -> 16..%d (256)\n",
  86.         PRED(SCREEN_SIZE_X_MAX));
  87.   WRITE(ERROR, "  [h]Screen Height      -> 16..%d (256)\n",
  88.         PRED(SCREEN_SIZE_Y_MAX));
  89.   WRITE(ERROR, "  [p]Sampling Levels    -> 0..%d (0)\n", SAMPLING_LEVEL_MAX);
  90.   WRITE(ERROR, "  [A]Aliasing Threshold -> 0..1 (0.05)\n");
  91.   WRITE(ERROR, "  [s]Shading Levels     -> 1..%d (8)\n", last_shade_level);
  92.   WRITE(ERROR, "  [S]Shading Threshold  -> 0..1 (0.01) \n");
  93.   WRITE(ERROR, "  [d]Ambient Levels     -> 0..%d (0)\n", last_shade_level);
  94.   WRITE(ERROR, "  [D]Ambient Samples    -> 2..%d (16)\n", SCREEN_SIZE_X_MAX);
  95.   WRITE(ERROR, "  [T]Ambient Threshold  -> 0..1 (0)\n");
  96.   WRITE(ERROR, "  [c]Cluster Size       -> %d..%d (4)\n",
  97.         CLUSTER_SIZE_MIN, CLUSTER_SIZE_MAX);
  98.   WRITE(ERROR, "  [a]Antialiasing Mode  -> 0, 1, 2 (0)\n");
  99.   WRITE(ERROR, "  [i]Intersect Mode     -> 0, 1 (0)\n");
  100.   WRITE(ERROR, "  [I]Inter. Adjust Mode -> 0, 1 (0)\n");
  101.   WRITE(ERROR, "  [j]Jittering Mode     -> 0, 1 (0)\n");
  102.   WRITE(ERROR, "  [l]Lighting Mode      -> 0, 1, 2 (0)\n");
  103.   WRITE(ERROR, "  [m]Shading Mode       -> 0, 1 (1)\n");
  104.   WRITE(ERROR, "  [n]Normal Mode        -> 0, 1 (0)\n");
  105.   WRITE(ERROR, "  [t]Texture Mode       -> 0, 1, 2 (0)\n");
  106.   WRITE(ERROR, "  [v]View Mode          -> 0, 1, 2 (0)\n");
  107.   WRITE(ERROR, "  [z]Normal Check Mode  -> 0, 1 (0)\n");
  108.   WRITE(ERROR, "  [B]Mask Back File     -> FILE (PIC format)\n");
  109.   WRITE(ERROR, "  [R]Raw Picture File   -> FILE (PIC format)\n");
  110.   WRITE(ERROR, "  [F]Focal Distance     -> 0..%0.0f (GAZE)\n", X_MAX);
  111.   WRITE(ERROR, "  [E]Stereo Separation  -> 0..%0.0f\n", X_MAX);
  112.   WRITE(ERROR, "  [P]Focal Aperture     -> 0..1\n");
  113.   WRITE(ERROR, "  [O]Output Format      -> 0 - PIC format, 1 - PPM (0)\n");
  114.   WRITE(ERROR, "  [V]Verbose Mode       -> 0, 1, 2, 3 (2)\n");
  115.   WRITE(ERROR, "  {-|INFILE} {-|OUTFILE} [>LOGFILE]\n");
  116. }
  117. #define MIN_PARAMETERS (2)
  118.  
  119. #define GET_INT(number)\
  120. do { PROCESS_MAC_EVENT\
  121.   IO_status = (sscanf(&(parameter[option][1]), "%hd", &(number)) == 1) ?\
  122.     IO_OK : IO_READ;\
  123. } while (0)
  124.  
  125. #define GET_REAL(number)\
  126. do { PROCESS_MAC_EVENT\
  127.   IO_status = (sscanf(&(parameter[option][1]), "%lf", &(number)) == 1) ?\
  128.     IO_OK : IO_READ;\
  129. } while (0)
  130.  
  131. void
  132. get_parameters(parameters, parameter)
  133.   int             parameters;   /* Command parameter count */
  134.   char_ptr        parameter[];
  135. {
  136.   int             option;
  137.  
  138.   defaults();
  139.   if (parameters < MIN_PARAMETERS)
  140.   {
  141.     WRITE(ERROR, "Error: PARAMETER(S) missing\n");
  142.     usage();
  143.     HALT;
  144.   }
  145.   for (option = 0; option < parameters - MIN_PARAMETERS; POSINC(option))
  146.   {
  147.     switch (parameter[option][0])
  148.     {
  149.       case 'a':
  150.         GET_INT(antialiasing_mode);
  151.         if ((IO_status != IO_OK)
  152.             OR(antialiasing_mode < 0) OR(antialiasing_mode > 2))
  153.         {
  154.           WRITE(ERROR, "Error: bad ANTIALIASING MODE\n");
  155.           HALT;
  156.         }
  157.         break;
  158.  
  159.       case 'c':
  160.         GET_INT(cluster_size);
  161.         if ((IO_status != IO_OK)
  162.             OR(cluster_size < CLUSTER_SIZE_MIN)
  163.             OR(cluster_size > CLUSTER_SIZE_MAX))
  164.         {
  165.           WRITE(ERROR, "Error: bad CLUSTER SIZE\n");
  166.           HALT;
  167.         }
  168.         break;
  169.  
  170.       case 'd':
  171.         GET_INT(last_ambient_level);
  172.         if ((IO_status != IO_OK)
  173.             OR(last_ambient_level < 0)
  174.             OR(last_ambient_level > last_shade_level))
  175.         {
  176.           WRITE(ERROR, "Error: bad AMBIENT LEVELS\n");
  177.           HALT;
  178.         }
  179.         break;
  180.  
  181.       case 'h':
  182.         GET_INT(screen_size_y);
  183.         if ((IO_status != IO_OK) OR(screen_size_y < 16)
  184.             OR(screen_size_y >= SCREEN_SIZE_Y_MAX))
  185.         {
  186.           WRITE(ERROR, "Error: bad SCREEN HEIGHT\n");
  187.           HALT;
  188.         }
  189.         break;
  190.  
  191.       case 'i':
  192.         GET_INT(intersect_mode);
  193.         if ((IO_status != IO_OK)
  194.             OR(intersect_mode < 0) OR(intersect_mode > 1))
  195.         {
  196.           WRITE(ERROR, "Error: bad INTERSECT MODE\n");
  197.           HALT;
  198.         }
  199.         break;
  200.  
  201.       case 'j':
  202.         GET_INT(jittering_mode);
  203.         if ((IO_status != IO_OK)
  204.             OR(jittering_mode < 0) OR(jittering_mode > 1))
  205.         {
  206.           WRITE(ERROR, "Error: bad JITTERING MODE\n");
  207.           HALT;
  208.         }
  209.         break;
  210.  
  211.       case 'l':
  212.         GET_INT(light_mode);
  213.         if ((IO_status != IO_OK)
  214.             OR(light_mode < 0) OR(light_mode > 2))
  215.         {
  216.           WRITE(ERROR, "Error: bad LIGHTING MODE\n");
  217.           HALT;
  218.         }
  219.         break;
  220.  
  221.       case 'm':
  222.         GET_INT(shade_mode);
  223.         if ((IO_status != IO_OK)
  224.             OR(shade_mode < 0) OR(shade_mode > 1))
  225.         {
  226.           WRITE(ERROR, "Error: bad SHADING MODE\n");
  227.           HALT;
  228.         }
  229.         break;
  230.  
  231.       case 'n':
  232.         GET_INT(normal_mode);
  233.         if ((IO_status != IO_OK)
  234.             OR(normal_mode < 0) OR(normal_mode > 1))
  235.         {
  236.           WRITE(ERROR, "Error: bad NORMAL MODE\n");
  237.           HALT;
  238.         }
  239.         break;
  240.  
  241.       case 'p':
  242.         GET_INT(sampling_levels);
  243.         if ((IO_status != IO_OK)
  244.             OR(sampling_levels < 0) OR(sampling_levels > SAMPLING_LEVEL_MAX))
  245.         {
  246.           WRITE(ERROR, "Error: bad SAMPLING LEVEL(S)\n");
  247.           HALT;
  248.         }
  249.         sampling_divisions = 1 SHL sampling_levels;
  250.         sampling_weight = 4 * SQR(sampling_divisions);
  251.         break;
  252.  
  253.       case 's':
  254.         GET_INT(last_shade_level);
  255.         if ((IO_status != IO_OK) OR(last_shade_level <= 0))
  256.         {
  257.           WRITE(ERROR, "Error: bad SHADING LEVEL(S)\n");
  258.           HALT;
  259.         }
  260.         POSDEC(last_shade_level);
  261.         break;
  262.  
  263.       case 't':
  264.         GET_INT(texture_mode);
  265.         if ((IO_status != IO_OK)
  266.             OR(texture_mode < 0) OR(texture_mode > 2))
  267.         {
  268.           WRITE(ERROR, "Error: bad TEXTURE MODE\n");
  269.           HALT;
  270.         }
  271.         break;
  272.  
  273.       case 'v':
  274.         GET_INT(view_mode);
  275.         if ((IO_status != IO_OK)
  276.             OR(view_mode < 0) OR(view_mode > 2))
  277.         {
  278.           WRITE(ERROR, "Error: bad VIEW MODE\n");
  279.           HALT;
  280.         }
  281.         break;
  282.  
  283.       case 'w':
  284.         GET_INT(screen_size_x);
  285.         if ((IO_status != IO_OK) OR(screen_size_x < 16)
  286.             OR(screen_size_x >= SCREEN_SIZE_X_MAX))
  287.         {
  288.           WRITE(ERROR, "Error: bad SCREEN WIDTH\n");
  289.           HALT;
  290.         }
  291.         break;
  292.  
  293.       case 'z':
  294.         GET_INT(normal_check_mode);
  295.         if ((IO_status != IO_OK)
  296.             OR(normal_check_mode < 0) OR(normal_check_mode > 1))
  297.         {
  298.           WRITE(ERROR, "Error: bad NORMAL CHECK MODE\n");
  299.           HALT;
  300.         }
  301.         break;
  302.  
  303.       case 'A':
  304.         GET_REAL(threshold_color);
  305.         if ((IO_status != IO_OK) OR(threshold_color <= 0.0)
  306.             OR(threshold_color >= 1.0))
  307.         {
  308.           WRITE(ERROR, "Error: bad ALIASING THRESHOLD\n");
  309.           HALT;
  310.         }
  311.         threshold_color = SQR(threshold_color) * 3.0;
  312.         break;
  313.  
  314.       case 'B':
  315.         if (background_mode == 1)
  316.         {
  317.           WRITE(ERROR, "Error: BACKGROUND MODE already set\n");
  318.           HALT;
  319.         }
  320.         OPEN(background, &(parameter[option][1]), WRITE_BINARY);
  321.         if (IO_status != IO_OK)
  322.         {
  323.           WRITE(ERROR, "Error: unable to open BACKGROUND MASK FILE (%s)\n",
  324.                 &(parameter[option][1]));
  325.           HALT;
  326.         }
  327.         background_mode = 1;
  328.         break;
  329.  
  330.       case 'D':
  331.         GET_INT(ambient_sample_rays);
  332.         if ((IO_status != IO_OK)
  333.             OR(ambient_sample_rays < 2)
  334.             OR(ambient_sample_rays > SCREEN_SIZE_X_MAX))
  335.         {
  336.           WRITE(ERROR, "Error: bad AMBIENT SAMPLES\n");
  337.           HALT;
  338.         }
  339.         break;
  340.  
  341.       case 'E':
  342.         GET_REAL(stereo_separation);
  343.         if ((IO_status != IO_OK)
  344.             OR(stereo_separation < -10.0) OR(stereo_separation > X_MAX))
  345.         {
  346.           WRITE(ERROR, "Error: bad STEREO SEPARATION\n");
  347.           HALT;
  348.         }
  349.         break;
  350.  
  351.       case 'F':
  352.         GET_REAL(focal_distance);
  353.         if ((IO_status != IO_OK)
  354.             OR(focal_distance < ROUNDOFF) OR(focal_distance > X_MAX))
  355.         {
  356.           WRITE(ERROR, "Error: bad FOCAL DISTANCE\n");
  357.           HALT;
  358.         }
  359.         break;
  360.  
  361.       case 'I':
  362.         GET_INT(intersect_adjust_mode);
  363.         if ((IO_status != IO_OK)
  364.             OR(intersect_adjust_mode < 0) OR(intersect_adjust_mode > 1))
  365.         {
  366.           WRITE(ERROR, "Error: bad INTERSECT ADJUST MODE\n");
  367.           HALT;
  368.         }
  369.         break;
  370.  
  371.       case 'O':
  372.         GET_INT(output_format);
  373.         if ((IO_status != IO_OK)
  374.             OR(output_format < 0) OR(output_format > 1))
  375.         {
  376.           WRITE(ERROR, "Error: bad OUTPUT FORMAT\n");
  377.           HALT;
  378.         }
  379.         break;
  380.  
  381.       case 'P':
  382.         GET_REAL(focal_aperture);
  383.         if ((IO_status != IO_OK)
  384.             OR(focal_aperture < ROUNDOFF) OR(focal_aperture > 1.0))
  385.         {
  386.           WRITE(ERROR, "Error: bad FOCAL APERTURE\n");
  387.           HALT;
  388.         }
  389.         break;
  390.  
  391.       case 'R':
  392.         if (raw_mode == 1)
  393.         {
  394.           WRITE(ERROR, "Error: RAW MODE already set\n");
  395.           HALT;
  396.         }
  397.         OPEN(raw_picture, &(parameter[option][1]), WRITE_BINARY);
  398.         if (IO_status != IO_OK)
  399.         {
  400.           WRITE(ERROR, "Error: unable to open RAW PICTURE FILE (%s)\n",
  401.                 &(parameter[option][1]));
  402.           HALT;
  403.         }
  404.         raw_mode = 1;
  405.         break;
  406.  
  407.       case 'S':
  408.         GET_REAL(threshold_level);
  409.         if ((IO_status != IO_OK) OR(threshold_level <= 0.0)
  410.             OR(threshold_level >= 1.0))
  411.         {
  412.           WRITE(ERROR, "Error: bad SHADING THRESHOLD\n");
  413.           HALT;
  414.         }
  415.         break;
  416.  
  417.       case 'T':
  418.         GET_REAL(threshold_vector);
  419.         if ((IO_status != IO_OK) OR(threshold_vector < 0.0)
  420.             OR(threshold_vector >= 1.0))
  421.         {
  422.           WRITE(ERROR, "Error: bad AMBIENT THRESHOLD\n");
  423.           HALT;
  424.         }
  425.         distributed_cache_mode = (threshold_vector > ROUNDOFF);
  426.         break;
  427.  
  428.       case 'V':
  429.         GET_INT(verbose_mode);
  430.         if ((IO_status != IO_OK)
  431.             OR(verbose_mode < 0) OR(verbose_mode > 3))
  432.         {
  433.           WRITE(ERROR, "Error: bad VERBOSE MODE\n");
  434.           HALT;
  435.         }
  436.         break;
  437.  
  438.       default:
  439.         WRITE(ERROR, "Error: bad OPTION [%c]\n", parameter[option][0]);
  440.         usage();
  441.         HALT;
  442.         break;
  443.     }
  444.   }
  445.   if ((screen_size_x == 0) AND(screen_size_y == 0))
  446.   {
  447.     screen_size_x = 256;
  448.     screen_size_y = 256;
  449.   } else
  450.   if (screen_size_x == 0)
  451.     screen_size_x = screen_size_y;
  452.   else
  453.   if (screen_size_y == 0)
  454.     screen_size_y = screen_size_x;
  455.   if ((view_mode == 0) AND(ABS(stereo_separation) > ROUNDOFF))
  456.   {
  457.     WRITE(ERROR, "Error: cannot have STEREO SEPARATION\n");
  458.     HALT;
  459.   }
  460.   if ((view_mode != 0) AND(ABS(stereo_separation) < ROUNDOFF))
  461.   {
  462.     WRITE(ERROR, "Error: no STEREO SEPARATION\n");
  463.     HALT;
  464.   }
  465.   if (threshold_color > THRESHOLD_COLOR(0.9))
  466.   {
  467.     sampling_levels = 0;
  468.     sampling_divisions = 1 SHL sampling_levels;
  469.     sampling_weight = 4 * SQR(sampling_divisions);
  470.   }
  471.   if (distributed_cache_mode != 0)
  472.   {
  473.     distributed_cache_repetitions = MAX(8, threshold_vector * screen_size_x);
  474.     threshold_vector = 1.0 - threshold_vector;
  475.   } else
  476.     threshold_vector = 1.0;
  477.   if ((parameter[option][0] == '-') AND(parameter[option][1] == EOT))
  478.     scene = INPUT;
  479.   else
  480.   {
  481.     OPEN(scene, parameter[option], READ_TEXT);
  482.     if (IO_status != IO_OK)
  483.     {
  484.       WRITE(ERROR, "Error: unable to open SCENE (%s)\n",
  485.             parameter[option]);
  486.       HALT;
  487.     }
  488.   }
  489.   POSINC(option);
  490.   if ((parameter[option][0] == '-') AND(parameter[option][1] == EOT))
  491.   {
  492.     picture = OUTPUT;
  493.     results = ERROR;
  494.   } else
  495.   {
  496.     OPEN(picture, parameter[option], WRITE_BINARY);
  497.     if (IO_status != IO_OK)
  498.     {
  499.       WRITE(ERROR, "Error: unable to open PICTURE (%s)\n",
  500.             parameter[option]);
  501.       HALT;
  502.     }
  503.     results = OUTPUT;
  504.   }
  505.   /*
  506.    * Memory allocation
  507.    */
  508.  
  509. #ifdef THINK_C
  510.  
  511.     /* On the mac, when do_enclose is TRUE, the scene is already in memory, so
  512.         we don't want to throw away the existing ALLOCations, since they
  513.         contain important scene information.  We use the old ones. */
  514.  
  515.     if (do_enclose)
  516.         {
  517.         ALLOCATE(object, object_ptr, OBJECTS_MAX);
  518.         ALLOCATE(surface, surface_ptr, SURFACES_MAX);
  519.         ALLOCATE(pqueue, pqueue_struct, PQUEUE_SIZE_MAX);
  520.         }
  521.     
  522.     else
  523.         {
  524.         
  525.         /* Free memory used by new_line and old_line in previous render */
  526.         FREE(new_line);
  527.         FREE(old_line);
  528.         
  529.         }
  530.  
  531. #else
  532.  
  533.   ALLOCATE(object, object_ptr, OBJECTS_MAX);
  534.   ALLOCATE(surface, surface_ptr, SURFACES_MAX);
  535.   ALLOCATE(pqueue, pqueue_struct, PQUEUE_SIZE_MAX);
  536.  
  537. #endif
  538.  
  539.   ALLOCATE(new_line, pixel_struct, SCREEN_SIZE_X_MAX);
  540.   ALLOCATE(old_line, pixel_struct, SCREEN_SIZE_X_MAX);
  541.  
  542.   if (verbose_mode == 0)
  543.     return;
  544.  
  545.   WRITE(results, "Image width        : %d\n", screen_size_x);
  546.   WRITE(results, "Image height       : %d\n", screen_size_y);
  547.   WRITE(results, "Aliasing threshold : %g\n", sampling_levels ?
  548.         SQRT(threshold_color / 3.0) : 1.0);
  549.   WRITE(results, "Shading threshold  : %g\n", last_shade_level ?
  550.         threshold_level : 1.0);
  551.   WRITE(results, "Ambient threshold  : %g\n", last_ambient_level ?
  552.         1.0 - threshold_vector : 1.0);
  553.   WRITE(results, "Sampling levels    : %d\n", sampling_levels);
  554.   WRITE(results, "Shading levels     : %d\n", SUCC(last_shade_level));
  555.   WRITE(results, "Ambient levels     : %d\n", last_ambient_level);
  556.   WRITE(results, "Ambient samples    : %d\n", last_ambient_level ?
  557.         ambient_sample_rays : 0);
  558.   WRITE(results, "Cluster size       : %d\n", cluster_size);
  559.   WRITE(results, "Antialiasing mode  : ");
  560.   if (sampling_levels == 0)
  561.     WRITE(results, "PIXEL CORNER AVERAGE\n");
  562.   else
  563.     switch (antialiasing_mode)
  564.     {
  565.     case 0:
  566.       WRITE(results, "PIXEL ADAPTIVE SUPERSAMPLING\n");
  567.       break;
  568.     case 1:
  569.       WRITE(results, "PIXEL SEMI-ADAPTIVE SUPERSAMPLING\n");
  570.       break;
  571.     case 2:
  572.       WRITE(results, "PIXEL SUPERSAMPLING\n");
  573.       break;
  574.     }
  575.   WRITE(results, "Background mode    : %s\n", background_mode ? "ON" : "OFF");
  576.   WRITE(results, "Intersect mode     : %s\n",
  577.         (intersect_mode OR(antialiasing_mode == 2)) ?
  578.         "ALL OBJECTS" : "PIXEL CORNER OBJECTS");
  579.   WRITE(results, "Inters. adjust mode: %s\n",
  580.         intersect_adjust_mode ? "ON" : "OFF");
  581.   WRITE(results, "Jittering mode     : %s\n", jittering_mode ? "ON" : "OFF");
  582.   WRITE(results, "Lighting mode      : ");
  583.   switch (light_mode)
  584.   {
  585.   case 0:
  586.     WRITE(results, "NO TRANSLUCENT SHADOWS\n");
  587.     break;
  588.   case 1:
  589.     WRITE(results, "PARTIAL TRANSLUCENT SHADOWS\n");
  590.     break;
  591.   case 2:
  592.     WRITE(results, "FULL TRANSLUCENT SHADOWS\n");
  593.     break;
  594.   }
  595.   WRITE(results, "Normal mode        : %s\n", normal_mode ?
  596.         "NORMAL CORRECTION" : "NO NORMAL CORRECTION");
  597.   WRITE(results, "Normal check mode  : %s\n", normal_check_mode ?
  598.         "NORMAL TEXTURE CORRECTION" : "NO NORMAL TEXTURE CORRECTION");
  599.   WRITE(results, "Shading mode       : %s\n", shade_mode ?
  600.         "STRAUSS MODEL" : "PHONG MODEL");
  601.   WRITE(results, "Raw mode           : %s\n", raw_mode ? "ON" : "OFF");
  602.   WRITE(results, "Texture mode       : ");
  603.   switch (texture_mode)
  604.   {
  605.   case 0:
  606.     WRITE(results, "NO TEXTURES\n");
  607.     break;
  608.   case 1:
  609.     WRITE(results, "TEXTURES INSIDE OBJECTS DESCRIPTION\n");
  610.     break;
  611.   case 2:
  612.     WRITE(results, "TEXTURES AFTER OBJECTS DESCRIPTION\n");
  613.     break;
  614.   }
  615.   WRITE(results, "View mode          : ");
  616.   switch (view_mode)
  617.   {
  618.   case 0:
  619.     WRITE(results, "NORMAL\n");
  620.     break;
  621.   case 1:
  622.     WRITE(results, "LEFT EYE\n");
  623.     break;
  624.   case 2:
  625.     WRITE(results, "RIGHT EYE\n");
  626.     break;
  627.   }
  628.   if (focal_aperture > ROUNDOFF)
  629.     WRITE(results, "Focal aperture     : %g\n", focal_aperture);
  630.   else
  631.     WRITE(results, "Focal aperture     : %s\n", "0 - PINHOLE CAMERA");
  632.   if (focal_distance > ROUNDOFF)
  633.     WRITE(results, "Focal distance     : %g\n", focal_distance);
  634.   else
  635.     WRITE(results, "Focal distance     : %s\n", "GAZE");
  636.   if (stereo_separation > ROUNDOFF)
  637.     WRITE(results, "Stereo separation  : %g\n", stereo_separation);
  638.   if (stereo_separation < -ROUNDOFF)
  639.     WRITE(results, "Stereo separation  : %g%% of GAZE\n",
  640.           -stereo_separation * 100.0);
  641.   WRITE(results, "Output format      : %s\n", output_format ? "PPM" : "PIC");
  642.   WRITE(results, "Info: options ok\n");
  643.   FLUSH(results);
  644. }
  645.